package cn.study.concurrenttools.readwritelock;

import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.ReadWriteLock;

public class ReentrantReadWriteLockYM {


}
//
//public class ReentrantReadWriteLock
//        implements ReadWriteLock, java.io.Serializable {
//
//    /** 读锁 */
//    private final ReentrantReadWriteLock.ReadLock readerLock;
//
//    /** 写锁 */
//    private final ReentrantReadWriteLock.WriteLock writerLock;
//
//    final Sync sync;
//
//    /** 使用默认（非公平）的排序属性创建一个新的 ReentrantReadWriteLock */
//    public ReentrantReadWriteLock() {
//        this(false);
//    }
//
//    /** 使用给定的公平策略创建一个新的 ReentrantReadWriteLock */
//    public ReentrantReadWriteLock(boolean fair) {
//        sync = fair ? new FairSync() : new NonfairSync();
//        readerLock = new ReadLock(this);
//        writerLock = new WriteLock(this);
//    }
//
//    /** 返回用于写入操作的锁 */
//    public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
//
//    /** 返回用于读取操作的锁 */
//    public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }
//
//
//    abstract static class Sync extends AbstractQueuedSynchronizer {}
//
//    static final class NonfairSync extends Sync {}
//
//    static final class FairSync extends Sync {}
//
//    public static class ReadLock implements Lock, java.io.Serializable {}
//
//    public static class WriteLock implements Lock, java.io.Serializable {}
//
//    // 计数器 HoldCounter主要与读锁配套使用
//    // HoldCounter主要有两个属性，count和tid，其中count表示某个读线程重入的次数，
//    // tid表示该线程的tid字段的值，该字段可以用来唯一标识一个线程
//    static final class HoldCounter {
//        // 计数
//        int count = 0;
//        // Use id, not reference, to avoid garbage retention
//        // 获取当前线程的TID属性的值
//        final long tid = getThreadId(Thread.currentThread());
//    }
//
//    // 本地线程计数器
//    static final class ThreadLocalHoldCounter
//            extends ThreadLocal<HoldCounter> {
//        // 重写初始化方法，在没有进行set的情况下，获取的都是该HoldCounter值
//        // 保证初始化的对象都是线程私有的
//        public HoldCounter initialValue() {
//            return new HoldCounter();
//        }
//    }
//
//    abstract static class Sync extends AbstractQueuedSynchronizer {
//        // 版本序列号
//        private static final long serialVersionUID = 6317671515068378041L;
//        // 高16位为读锁，低16位为写锁
//        static final int SHARED_SHIFT   = 16;
//        // 读锁单位
//        static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
//        // 读锁最大数量
//        static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
//        // 写锁最大数量
//        static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
//        // 本地线程计数器
//        private transient ThreadLocalHoldCounter readHolds;
//        // 缓存的计数器
//        private transient HoldCounter cachedHoldCounter;
//        // 第一个读线程
//        private transient Thread firstReader = null;
//        // 第一个读线程的计数
//        private transient int firstReaderHoldCount;
//    }
//    /** ReadLock 获取锁 **/
//    protected final int tryAcquireShared(int unused) {
//        Thread current = Thread.currentThread();
//        int c = getState();
//        // 存在写锁且不是当前线程
//        if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current) return -1;
//        // 当前线程持有写锁或仅有读锁或无锁
//        int r = sharedCount(c);
//        // 根据公平锁和非公平锁重写 readerShouldBlock()
//        if (!readerShouldBlock() && r < MAX_COUNT && compareAndSetState(c, c + SHARED_UNIT)) {
//            // 如果是第一次获取 初始化 firstReader、firstReaderHoldCount 不是第一次获取 对 readHolds  对应线程计数+1
//            if (r == 0) {
//                // 第一次添加读锁
//                firstReader = current;
//                firstReaderHoldCount = 1;
//            } else if (firstReader == current) {
//                // firstReader 为当前线程
//                firstReaderHoldCount++;
//            } else {
//                // 否则更新 readHolds 对应线程读锁计数
//                HoldCounter rh = cachedHoldCounter;
//                if (rh == null || rh.tid != getThreadId(current)) cachedHoldCounter = rh = readHolds.get();
//                else if (rh.count == 0) readHolds.set(rh);
//                rh.count++;
//            }
//            return 1;
//        }
//        // 自旋尝试获取读锁（只要满足获取读锁条件）
//        return fullTryAcquireShared(current);
//    }
//
//
//    final int fullTryAcquireShared(Thread current) {
//        HoldCounter rh = null;
//        // 自旋 不挂起线程
//        for (; ; ) {
//            int c = getState();
//            if (exclusiveCount(c) != 0) {
//                // 非当前线程获取到写锁 获取失败
//                if (getExclusiveOwnerThread() != current)
//                    return -1;
//                // else we hold the exclusive lock; blocking here
//                // would cause deadlock.
//            } else if (readerShouldBlock()) {
//                // 走到这里说明没有写锁被占有 判断是否存在重入
//                // Make sure we're not acquiring read lock reentrantly
//                // 当前线程为 firstReader 走下面 CAS
//                if (firstReader == current) {
//                    // assert firstReaderHoldCount > 0;
//                } else {
//                    if (rh == null) {
//                        rh = cachedHoldCounter;
//                        // cachedHoldCounter 没有缓存或缓存的不是当前线程
//                        if (rh == null || rh.tid != getThreadId(current)) {
//                            rh = readHolds.get();
//                            // 说明上一行是初始化 移除上面产生的初始化
//                            if (rh.count == 0)
//                                readHolds.remove();
//                        }
//                    }
//                    if (rh.count == 0)
//                        return -1;
//                }
//            }
//            // 是否已经达到读锁获取次数上限
//            if (sharedCount(c) == MAX_COUNT)
//                throw new Error("Maximum lock count exceeded");
//            // CAS 获取锁
//            if (compareAndSetState(c, c + SHARED_UNIT)) {
//                // 读锁初始化和计数
//                if (sharedCount(c) == 0) {
//                    // 第一次添加读锁
//                    firstReader = current;
//                    firstReaderHoldCount = 1;
//                } else if (firstReader == current) {
//                    // firstReader 为当前线程
//                    firstReaderHoldCount++;
//                } else {
//                    // 否则更新 readHolds 对应线程读锁计数
//                    if (rh == null)
//                        rh = cachedHoldCounter;
//                    if (rh == null || rh.tid != getThreadId(current))
//                        rh = readHolds.get();
//                    else if (rh.count == 0)
//                        readHolds.set(rh);
//                    rh.count++;
//                    cachedHoldCounter = rh; // cache for release
//                }
//                return 1;
//            }
//        }
//    }
//
//    /** ReadLock 释放锁 **/
//    protected final boolean tryReleaseShared(int unused) {
//        Thread current = Thread.currentThread();
//        // 根据共享锁次数来设置 firstReader 不存在并发修改问题
//        if (firstReader == current) {
//            // assert firstReaderHoldCount > 0;
//            if (firstReaderHoldCount == 1)
//                firstReader = null;
//            else
//                firstReaderHoldCount--;
//        } else {
//            Sync.HoldCounter rh = cachedHoldCounter;
//            if (rh == null || rh.tid != getThreadId(current))
//                rh = readHolds.get();
//            int count = rh.count;
//            if (count <= 1) {
//                readHolds.remove();
//                if (count <= 0)
//                    throw unmatchedUnlockException();
//            }
//            --rh.count;
//        }
//        //  CAS 更新 state  保证一定能释放掉读锁的占有
//        for (; ; ) {
//            int c = getState();
//            int nextc = c - SHARED_UNIT;
//            if (compareAndSetState(c, nextc))
//                // Releasing the read lock has no effect on readers,
//                // but it may allow waiting writers to proceed if
//                // both read and write locks are now free.
//                return nextc == 0;
//        }
//    }
//
//    /** WriteLock 获取锁 **/
//    protected final boolean tryAcquire(int acquires) {
//        Thread current = Thread.currentThread();
//        int c = getState();
//        int w = exclusiveCount(c);
//        // 存在读锁或写锁
//        if (c != 0) {
//            // (Note: if c != 0 and w == 0 then shared count != 0)
//            // 存在读锁或存在写锁但不是当前线程持有获取失败
//            if (w == 0 || current != getExclusiveOwnerThread()) return false;
//            // 获取锁是否超过上限
//            if (w + exclusiveCount(acquires) > MAX_COUNT) throw new Error("Maximum lock count exceeded");
//            // Reentrant acquire
//            // 走到这里说明当前线程持有写锁 重入
//            setState(c + acquires);
//            return true;
//        }
//        // 不存在锁 判断公平非公平阻塞策略 || 进行 CAS 尝试获取锁
//        if (writerShouldBlock() || !compareAndSetState(c, c + acquires)) return false;
//        setExclusiveOwnerThread(current);
//        return true;
//    }
//
//
//    /** WriteLock 释放锁 **/
//
//    //AQS中定义了tryAcquire抽象方法，具体的实现由子类去实现
//    protected final boolean tryRelease(int releases) {
//        if (!isHeldExclusively())
//            throw new IllegalMonitorStateException();
//        int nextc = getState() - releases;
//        boolean free = exclusiveCount(nextc) == 0;
//        if (free)
//            setExclusiveOwnerThread(null);
//        setState(nextc);
//        return free;
//    }

//}